home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / 3D_GRAPH / G3D_MATR.C < prev    next >
Text File  |  1989-08-28  |  6KB  |  333 lines
  1. /*
  2.     Copyright '89    Christopher Moll
  3.     all rights reserved
  4. */
  5.  
  6.  
  7. #include    "graph3D.h"
  8. #include    <math.h>
  9. #ifndef    _LSC3_
  10. #    include    <QuickDraw.h>
  11. #endif
  12.  
  13.  
  14. extern    Real    rotMatrx[3][3];
  15. extern    Real    scale;
  16. extern    Point    Origin;
  17.  
  18.  
  19. extern    Real    rotMatrx[3][3];
  20.  
  21. Fixed    _rotMatrx[3][3];
  22.  
  23.  
  24. FxMatrxToMatrx(fxMat, matrx)
  25. register    Fixed    fxMat[3][3];
  26. register    Real    matrx[3][3];
  27. {
  28.     register    int    i, j;
  29.  
  30.     for (i = 0; i < 3; i++)
  31.         for (j = 0; j < 3; j++)
  32.             matrx[i][j] = FixToD(fxMat[i][j]);
  33. }
  34.  
  35. FxConv3VtoPt(vectP, cnvPntP)
  36. FxVector    *vectP;
  37. register    Point    *cnvPntP;
  38. {
  39.     FxVector result;
  40.  
  41.     FxMatrxMul(_rotMatrx, vectP, &result);
  42.  
  43.     cnvPntP->h = FixToi((result.y)) + Origin.h;
  44.     cnvPntP->v = FixToi((-result.z)) + Origin.v;
  45. }
  46.  
  47. /**** Matrix to rotate 3-vector on three axes ****/
  48. FxMkRotMat(Xrot, Yrot, Zrot, matrx)
  49. Real Xrot, Yrot, Zrot;
  50. register    Fixed    matrx[3][3];
  51. {
  52.     Real cXrot , cYrot , cZrot ;
  53.     Real sXrot , sYrot , sZrot ;
  54.  
  55.     cXrot = cos(Xrot);
  56.     cYrot = cos(Yrot);
  57.     cZrot = cos(Zrot);
  58.     sXrot = sin(Xrot);
  59.     sYrot = sin(Yrot);
  60.     sZrot = sin(Zrot);
  61.  
  62.  
  63.     matrx[0][0] = DToFix(cYrot * cZrot);
  64.     matrx[0][1] = DToFix(cZrot * sXrot * sYrot - sZrot * cXrot);
  65.     matrx[0][2] = DToFix(-(cXrot * cZrot * sYrot + sXrot * sZrot));
  66.     matrx[1][0] = DToFix(sZrot * cYrot);
  67.     matrx[1][1] = DToFix(sXrot * sYrot * sZrot + cXrot * cZrot);
  68.     matrx[1][2] = DToFix(-sYrot * sZrot * cXrot + sXrot * cZrot);
  69.     matrx[2][0] = DToFix(sYrot);
  70.     matrx[2][1] = DToFix(-sXrot * cYrot);
  71.     matrx[2][2] = DToFix(cXrot * cYrot);
  72. }
  73.  
  74.  
  75. FxMkXRotMat(Xrot, matrx)
  76. Real        Xrot;
  77. register    Fixed    matrx[3][3];
  78. {
  79.     Fixed    cXrot, sXrot;
  80.  
  81.     FxMkIDMat(matrx);
  82.  
  83.     cXrot = DToFix(cos(Xrot));
  84.     sXrot = DToFix(sin(Xrot));
  85.  
  86.     matrx[1][1] = cXrot;
  87.     matrx[1][2] = sXrot;
  88.     matrx[2][1] = -sXrot;
  89.     matrx[2][2] = cXrot;
  90. }
  91.  
  92. FxMkYRotMat(Yrot, matrx)
  93. Real        Yrot;
  94. register    Fixed    matrx[3][3];
  95. {
  96.     Fixed    cYrot, sYrot;
  97.  
  98.     FxMkIDMat(matrx);
  99.  
  100.     cYrot = DToFix(cos(Yrot));
  101.     sYrot = DToFix(sin(Yrot));
  102.  
  103.     matrx[0][0] = cYrot;
  104.     matrx[0][2] = -sYrot;
  105.     matrx[2][0] = sYrot;
  106.     matrx[2][2] = cYrot;
  107. }
  108.  
  109. FxMkZRotMat(Zrot, matrx)
  110. Real        Zrot;
  111. register    Fixed    matrx[3][3];
  112. {
  113.     Fixed    cZrot, sZrot;
  114.  
  115.     FxMkIDMat(matrx);
  116.  
  117.     cZrot = DToFix(cos(Zrot));
  118.     sZrot = DToFix(sin(Zrot));
  119.  
  120.     matrx[0][0] = cZrot;
  121.     matrx[0][1] = -sZrot;
  122.     matrx[1][0] = sZrot;
  123.     matrx[1][1] = cZrot;
  124. }
  125.  
  126. FxMkIDMat(matrx)
  127. register    Fixed    matrx[3][3];
  128. {
  129.     matrx[0][0] = FIX_1;
  130.     matrx[0][1] = FIX_0;
  131.     matrx[0][2] = FIX_0;
  132.     matrx[1][0] = FIX_0;
  133.     matrx[1][1] = FIX_1;
  134.     matrx[1][2] = FIX_0;
  135.     matrx[2][0] = FIX_0;
  136.     matrx[2][1] = FIX_0;
  137.     matrx[2][2] = FIX_1;
  138. }
  139.  
  140. FxMatrxMul(mat, vect, resVect)
  141. register    Fixed    mat[3][3];
  142. register    FxVector    *vect;
  143. register    FxVector    *resVect;
  144. {
  145.     resVect->x =
  146.         FixMul(mat[0][0], vect->x) +
  147.         FixMul(mat[0][1], vect->y) +
  148.         FixMul(mat[0][2], vect->z);
  149.     resVect->y =
  150.         FixMul(mat[1][0], vect->x) +
  151.         FixMul(mat[1][1], vect->y) +
  152.         FixMul(mat[1][2], vect->z);
  153.     resVect->z =
  154.         FixMul(mat[2][0], vect->x) +
  155.         FixMul(mat[2][1], vect->y) +
  156.         FixMul(mat[2][2], vect->z);
  157. }
  158.  
  159. FxMatrxByMatrx(mat1, mat2, resMat)
  160. register    Fixed    mat1[3][3], mat2[3][3], resMat[3][3];
  161. {
  162.     register    int    i, j;
  163.  
  164.     for(i = 0; i < 3; i++)
  165.         for(j = 0; j < 3; j++)
  166.             resMat[i][j] =    FixMul(mat1[i][0], mat2[0][j]) +
  167.                             FixMul(mat1[i][1], mat2[1][j]) +
  168.                             FixMul(mat1[i][2], mat2[2][j]);
  169. }
  170.  
  171. FxCopyMat(sorc, dest)
  172. register    cpyFx3Matrx    *sorc, *dest;
  173. {
  174.     *dest = *sorc;
  175. }
  176.  
  177.  
  178.  
  179. /*---------------------------------------------------------------------------*/
  180.  
  181.  
  182.  
  183.  
  184. Conv3VtoPt(vectP, cnvPntP)
  185. Vector    *vectP;
  186. register    Point    *cnvPntP;
  187. {
  188.     Vector result;
  189.  
  190.     MatrxMul(rotMatrx, vectP, &result);
  191.  
  192.     cnvPntP->h = result.y + Origin.h;
  193.     cnvPntP->v = (-result.z) + Origin.v;
  194. }
  195.  
  196. MatrxMul(mat, vect, resVect)
  197. register    Real    mat[3][3];
  198. register    Vector    *vect;
  199. register    Vector    *resVect;
  200. {
  201.     resVect->x =
  202.         mat[0][0] * vect->x + mat[0][1] * vect->y + mat[0][2] * vect->z;
  203.     resVect->y =
  204.         mat[1][0] * vect->x + mat[1][1] * vect->y + mat[1][2] * vect->z;
  205.     resVect->z =
  206.         mat[2][0] * vect->x + mat[2][1] * vect->y + mat[2][2] * vect->z;
  207. }
  208.  
  209. matrxByMatrx(mat1, mat2, resMat)
  210. register    Real    mat1[3][3], mat2[3][3], resMat[3][3];
  211. {
  212.     register    int    i, j;
  213.  
  214.     for(i = 0; i < 3; i++)
  215.         for(j = 0; j < 3; j++)
  216.             resMat[i][j] =    mat1[i][0] * mat2[0][j] +
  217.                             mat1[i][1] * mat2[1][j] +
  218.                             mat1[i][2] * mat2[2][j];
  219. }
  220.  
  221. /**** Matrix to rotate 3-vector on three axes ****/
  222. MkRotMat(Xrot, Yrot, Zrot, matrx)
  223. Real Xrot, Yrot, Zrot;
  224. register    Real    matrx[3][3];
  225. {
  226.     Real cXrot , cYrot , cZrot ;
  227.     Real sXrot , sYrot , sZrot ;
  228.  
  229.     cXrot = cos(Xrot);
  230.     cYrot = cos(Yrot);
  231.     cZrot = cos(Zrot);
  232.     sXrot = sin(Xrot);
  233.     sYrot = sin(Yrot);
  234.     sZrot = sin(Zrot);
  235.  
  236.     matrx[0][0] = cYrot * cZrot;
  237.     matrx[0][1] = cZrot * sXrot * sYrot - sZrot * cXrot;
  238.     matrx[0][2] = -(cXrot * cZrot * sYrot + sXrot * sZrot);
  239.     matrx[1][0] = sZrot * cYrot;
  240.     matrx[1][1] = sXrot * sYrot * sZrot + cXrot * cZrot;
  241.     matrx[1][2] = -sYrot * sZrot * cXrot + sXrot * cZrot;
  242.     matrx[2][0] = sYrot;
  243.     matrx[2][1] = -sXrot * cYrot;
  244.     matrx[2][2] = cXrot * cYrot;
  245. }
  246.  
  247.  
  248. MatrxByMatrx(mat1, mat2, resMat)
  249. register    Real    mat1[3][3], mat2[3][3], resMat[3][3];
  250. {
  251.     register    int    i, j;
  252.  
  253.     for(i = 0; i < 3; i++)
  254.         for(j = 0; j < 3; j++)
  255.             resMat[i][j] =    mat1[i][0] * mat2[0][j] +
  256.                             mat1[i][1] * mat2[1][j] +
  257.                             mat1[i][2] * mat2[2][j];
  258. }
  259.  
  260.  
  261. CopyMat(sorc, dest)
  262. register    cpy3Matrx    *sorc, *dest;
  263. {
  264.     *dest = *sorc;
  265. }
  266.  
  267. MkIDMat(matrx)
  268. register    Real    matrx[3][3];
  269. {
  270.     matrx[0][0] = 1;
  271.     matrx[0][1] = 0;
  272.     matrx[0][2] = 0;
  273.     matrx[1][0] = 0;
  274.     matrx[1][1] = 1;
  275.     matrx[1][2] = 0;
  276.     matrx[2][0] = 0;
  277.     matrx[2][1] = 0;
  278.     matrx[2][2] = 1;
  279. }
  280.  
  281.  
  282.  
  283. MkXRotMat(Xrot, matrx)
  284. Real        Xrot;
  285. register    Real    matrx[3][3];
  286. {
  287.     Real    cXrot, sXrot;
  288.  
  289.     MkIDMat(matrx);
  290.  
  291.     cXrot = cos(Xrot);
  292.     sXrot = sin(Xrot);
  293.  
  294.     matrx[1][1] = cXrot;
  295.     matrx[1][2] = sXrot;
  296.     matrx[2][1] = -sXrot;
  297.     matrx[2][2] = cXrot;
  298. }
  299.  
  300. MkYRotMat(Yrot, matrx)
  301. Real        Yrot;
  302. register    Real    matrx[3][3];
  303. {
  304.     Real    cYrot, sYrot;
  305.  
  306.     MkIDMat(matrx);
  307.  
  308.     cYrot = cos(Yrot);
  309.     sYrot = sin(Yrot);
  310.  
  311.     matrx[0][0] = cYrot;
  312.     matrx[0][2] = -sYrot;
  313.     matrx[2][0] = sYrot;
  314.     matrx[2][2] = cYrot;
  315. }
  316.  
  317. MkZRotMat(Zrot, matrx)
  318. Real        Zrot;
  319. register    Real    matrx[3][3];
  320. {
  321.     Real    cZrot, sZrot;
  322.  
  323.     MkIDMat(matrx);
  324.  
  325.     cZrot = cos(Zrot);
  326.     sZrot = sin(Zrot);
  327.  
  328.     matrx[0][0] = cZrot;
  329.     matrx[0][1] = -sZrot;
  330.     matrx[1][0] = sZrot;
  331.     matrx[1][1] = cZrot;
  332. }
  333.